// --------------------------------------------------------------------------------------------------------------------
// <copyright file="NumericAssertionExtensions.cs" company="CSLib.Net Team">
//   Copyright (c) Roman "4ux-nbIx" Novitsky 2010
// </copyright>
// <summary>
//   Defines numeric assertion methods.
// </summary>
// --------------------------------------------------------------------------------------------------------------------

namespace CSLib.Net.Extensions
{
  using System.Diagnostics;

  using Annotations;

  using Diagnostics;

  // ReSharper disable ValueAnalysis

  /// <summary>
  /// Defines numeric assertion extension methods.
  /// </summary>
  [DebuggerStepThrough]
  [DebuggerNonUserCode]
  [UsedImplicitly(ImplicitUseKindFlags.Default, ImplicitUseTargetFlags.WithMembers)]
  public static class NumericAssertionExtensions
  {
    /// <summary>
    /// Asserts that the specified value is greater than zero.
    /// </summary>
    /// <param name="value">The value to check.</param>
    /// <param name="messageFormat">A composite format <see cref="string"/>.</param>
    /// <param name="messageArguments">An array of message arguments to format.</param>
    [Conditional("DEBUG")]
    [StringFormatMethod("messageFormat")]
    public static void AssertIsGreaterThanZero(
      this int value,
      [NotNull] string messageFormat,
      [CanBeNull] params object[] messageArguments)
    {
      Assert.IsTrue(value > 0, messageFormat, messageArguments);
    }

    /// <summary>
    /// Asserts that the specified value is greater than zero.
    /// </summary>
    /// <param name="value">The value to check.</param>
    /// <param name="messageFormat">A composite format <see cref="string"/>.</param>
    /// <param name="messageArguments">An array of message arguments to format.</param>
    [Conditional("DEBUG")]
    [StringFormatMethod("messageFormat")]
    public static void AssertIsGreaterThanZero(
      this float value,
      [NotNull] string messageFormat,
      [CanBeNull] params object[] messageArguments)
    {
      Assert.IsTrue(value > 0, messageFormat, messageArguments);
    }

    /// <summary>
    /// Asserts that the specified value is greater than zero.
    /// </summary>
    /// <param name="value">The value to check.</param>
    /// <param name="messageFormat">A composite format <see cref="string"/>.</param>
    /// <param name="messageArguments">An array of message arguments to format.</param>
    [Conditional("DEBUG")]
    [StringFormatMethod("messageFormat")]
    public static void AssertIsGreaterThanZero(
      this double value,
      [NotNull] string messageFormat,
      [CanBeNull] params object[] messageArguments)
    {
      Assert.IsTrue(value > 0, messageFormat, messageArguments);
    }

    /// <summary>
    /// Asserts that the specified value is greater than zero.
    /// </summary>
    /// <param name="value">The value to check.</param>
    /// <param name="messageFormat">A composite format <see cref="string"/>.</param>
    /// <param name="messageArguments">An array of message arguments to format.</param>
    [Conditional("DEBUG")]
    [StringFormatMethod("messageFormat")]
    public static void AssertIsGreaterThanZero(
      this decimal value,
      [NotNull] string messageFormat,
      [CanBeNull] params object[] messageArguments)
    {
      Assert.IsTrue(value > 0, messageFormat, messageArguments);
    }

    /// <summary>
    /// Asserts that the specified value is greater than zero.
    /// </summary>
    /// <param name="value">The value to check.</param>
    /// <param name="messageFormat">A composite format <see cref="string"/>.</param>
    /// <param name="messageArguments">An array of message arguments to format.</param>
    [Conditional("DEBUG")]
    [StringFormatMethod("messageFormat")]
    public static void AssertIsGreaterThanZero(
      this uint value,
      [NotNull] string messageFormat,
      [CanBeNull] params object[] messageArguments)
    {
      Assert.IsTrue(value > 0, messageFormat, messageArguments);
    }

    /// <summary>
    /// Asserts that the specified value is greater or equal to zero.
    /// </summary>
    /// <param name="value">The value to check.</param>
    /// <param name="messageFormat">A composite format <see cref="string"/>.</param>
    /// <param name="messageArguments">An array of message arguments to format.</param>
    [Conditional("DEBUG")]
    [StringFormatMethod("messageFormat")]
    public static void AssertIsGreaterOrEqualToZero(
      this int value,
      [NotNull] string messageFormat,
      [CanBeNull] params object[] messageArguments)
    {
      Assert.IsTrue(value >= 0, messageFormat, messageArguments);
    }

    /// <summary>
    /// Asserts that the specified value is greater or equal to zero.
    /// </summary>
    /// <param name="value">The value to check.</param>
    /// <param name="messageFormat">A composite format <see cref="string"/>.</param>
    /// <param name="messageArguments">An array of message arguments to format.</param>
    [Conditional("DEBUG")]
    [StringFormatMethod("messageFormat")]
    public static void AssertIsGreaterOrEqualToZero(
      this float value,
      [NotNull] string messageFormat,
      [CanBeNull] params object[] messageArguments)
    {
      Assert.IsTrue(value >= 0, messageFormat, messageArguments);
    }

    /// <summary>
    /// Asserts that the specified value is greater or equal to zero.
    /// </summary>
    /// <param name="value">The value to check.</param>
    /// <param name="messageFormat">A composite format <see cref="string"/>.</param>
    /// <param name="messageArguments">An array of message arguments to format.</param>
    [Conditional("DEBUG")]
    [StringFormatMethod("messageFormat")]
    public static void AssertIsGreaterOrEqualToZero(
      this double value,
      [NotNull] string messageFormat,
      [CanBeNull] params object[] messageArguments)
    {
      Assert.IsTrue(value >= 0, messageFormat, messageArguments);
    }

    /// <summary>
    /// Asserts that the specified value is greater or equal to zero.
    /// </summary>
    /// <param name="value">The value to check.</param>
    /// <param name="messageFormat">A composite format <see cref="string"/>.</param>
    /// <param name="messageArguments">An array of message arguments to format.</param>
    [Conditional("DEBUG")]
    [StringFormatMethod("messageFormat")]
    public static void AssertIsGreaterOrEqualToZero(
      this decimal value,
      [NotNull] string messageFormat,
      [CanBeNull] params object[] messageArguments)
    {
      Assert.IsTrue(value >= 0, messageFormat, messageArguments);
    }

    /// <summary>
    /// Asserts that the specified value is less than zero.
    /// </summary>
    /// <param name="value">The value to check.</param>
    /// <param name="messageFormat">A composite format <see cref="string"/>.</param>
    /// <param name="messageArguments">An array of message arguments to format.</param>
    [Conditional("DEBUG")]
    [StringFormatMethod("messageFormat")]
    public static void AssertIsLessThanZero(
      this int value,
      [NotNull] string messageFormat,
      [CanBeNull] params object[] messageArguments)
    {
      Assert.IsTrue(value < 0, messageFormat, messageArguments);
    }

    /// <summary>
    /// Asserts that the specified value is less than zero.
    /// </summary>
    /// <param name="value">The value to check.</param>
    /// <param name="messageFormat">A composite format <see cref="string"/>.</param>
    /// <param name="messageArguments">An array of message arguments to format.</param>
    [Conditional("DEBUG")]
    [StringFormatMethod("messageFormat")]
    public static void AssertIsLessThanZero(
      this float value,
      [NotNull] string messageFormat,
      [CanBeNull] params object[] messageArguments)
    {
      Assert.IsTrue(value < 0, messageFormat, messageArguments);
    }

    /// <summary>
    /// Asserts that the specified value is less than zero.
    /// </summary>
    /// <param name="value">The value to check.</param>
    /// <param name="messageFormat">A composite format <see cref="string"/>.</param>
    /// <param name="messageArguments">An array of message arguments to format.</param>
    [Conditional("DEBUG")]
    [StringFormatMethod("messageFormat")]
    public static void AssertIsLessThanZero(
      this double value,
      [NotNull] string messageFormat,
      [CanBeNull] params object[] messageArguments)
    {
      Assert.IsTrue(value < 0, messageFormat, messageArguments);
    }

    /// <summary>
    /// Asserts that the specified value is less than zero.
    /// </summary>
    /// <param name="value">The value to check.</param>
    /// <param name="messageFormat">A composite format <see cref="string"/>.</param>
    /// <param name="messageArguments">An array of message arguments to format.</param>
    [Conditional("DEBUG")]
    [StringFormatMethod("messageFormat")]
    public static void AssertIsLessThanZero(
      this decimal value,
      [NotNull] string messageFormat,
      [CanBeNull] params object[] messageArguments)
    {
      Assert.IsTrue(value < 0, messageFormat, messageArguments);
    }

    /// <summary>
    /// Asserts that the specified value is less or equal to zero.
    /// </summary>
    /// <param name="value">The value to check.</param>
    /// <param name="messageFormat">A composite format <see cref="string"/>.</param>
    /// <param name="messageArguments">An array of message arguments to format.</param>
    [Conditional("DEBUG")]
    [StringFormatMethod("messageFormat")]
    public static void AssertIsLessOrEqualToZero(
      this int value,
      [NotNull] string messageFormat,
      [CanBeNull] params object[] messageArguments)
    {
      Assert.IsTrue(value <= 0, messageFormat, messageArguments);
    }

    /// <summary>
    /// Asserts that the specified value is less or equal to zero.
    /// </summary>
    /// <param name="value">The value to check.</param>
    /// <param name="messageFormat">A composite format <see cref="string"/>.</param>
    /// <param name="messageArguments">An array of message arguments to format.</param>
    [Conditional("DEBUG")]
    [StringFormatMethod("messageFormat")]
    public static void AssertIsLessOrEqualToZero(
      this float value,
      [NotNull] string messageFormat,
      [CanBeNull] params object[] messageArguments)
    {
      Assert.IsTrue(value <= 0, messageFormat, messageArguments);
    }

    /// <summary>
    /// Asserts that the specified value is less or equal to zero.
    /// </summary>
    /// <param name="value">The value to check.</param>
    /// <param name="messageFormat">A composite format <see cref="string"/>.</param>
    /// <param name="messageArguments">An array of message arguments to format.</param>
    [Conditional("DEBUG")]
    [StringFormatMethod("messageFormat")]
    public static void AssertIsLessOrEqualToZero(
      this double value,
      [NotNull] string messageFormat,
      [CanBeNull] params object[] messageArguments)
    {
      Assert.IsTrue(value <= 0, messageFormat, messageArguments);
    }

    /// <summary>
    /// Asserts that the specified value is less or equal to zero.
    /// </summary>
    /// <param name="value">The value to check.</param>
    /// <param name="messageFormat">A composite format <see cref="string"/>.</param>
    /// <param name="messageArguments">An array of message arguments to format.</param>
    [Conditional("DEBUG")]
    [StringFormatMethod("messageFormat")]
    public static void AssertIsLessOrEqualToZero(
      this decimal value,
      [NotNull] string messageFormat,
      [CanBeNull] params object[] messageArguments)
    {
      Assert.IsTrue(value <= 0, messageFormat, messageArguments);
    }

    /// <summary>
    /// Asserts that the checked value is greater than the specified value.
    /// </summary>
    /// <param name="value">The value to check.</param>
    /// <param name="valueToCompareWith">The value to compare with.</param>
    /// <param name="messageFormat">A composite format <see cref="string"/>.</param>
    /// <param name="messageArguments">An array of message arguments to format.</param>
    [Conditional("DEBUG")]
    [StringFormatMethod("messageFormat")]
    public static void AssertIsGreater(
      this int value,
      int valueToCompareWith,
      [NotNull] string messageFormat,
      [CanBeNull] params object[] messageArguments)
    {
      Assert.IsTrue(value > valueToCompareWith, messageFormat, messageArguments);
    }

    /// <summary>
    /// Asserts that the checked value is greater than the specified value.
    /// </summary>
    /// <param name="value">The value to check.</param>
    /// <param name="valueToCompareWith">The value to compare with.</param>
    /// <param name="messageFormat">A composite format <see cref="string"/>.</param>
    /// <param name="messageArguments">An array of message arguments to format.</param>
    [Conditional("DEBUG")]
    [StringFormatMethod("messageFormat")]
    public static void AssertIsGreater(
      this float value,
      float valueToCompareWith,
      [NotNull] string messageFormat,
      [CanBeNull] params object[] messageArguments)
    {
      Assert.IsTrue(value > valueToCompareWith, messageFormat, messageArguments);
    }

    /// <summary>
    /// Asserts that the checked value is greater than the specified value.
    /// </summary>
    /// <param name="value">The value to check.</param>
    /// <param name="valueToCompareWith">The value to compare with.</param>
    /// <param name="messageFormat">A composite format <see cref="string"/>.</param>
    /// <param name="messageArguments">An array of message arguments to format.</param>
    [Conditional("DEBUG")]
    [StringFormatMethod("messageFormat")]
    public static void AssertIsGreater(
      this double value,
      double valueToCompareWith,
      [NotNull] string messageFormat,
      [CanBeNull] params object[] messageArguments)
    {
      Assert.IsTrue(value > valueToCompareWith, messageFormat, messageArguments);
    }

    /// <summary>
    /// Asserts that the checked value is greater than the specified value.
    /// </summary>
    /// <param name="value">The value to check.</param>
    /// <param name="valueToCompareWith">The value to compare with.</param>
    /// <param name="messageFormat">A composite format <see cref="string"/>.</param>
    /// <param name="messageArguments">An array of message arguments to format.</param>
    [Conditional("DEBUG")]
    [StringFormatMethod("messageFormat")]
    public static void AssertIsGreater(
      this decimal value,
      decimal valueToCompareWith,
      [NotNull] string messageFormat,
      [CanBeNull] params object[] messageArguments)
    {
      Assert.IsTrue(value > valueToCompareWith, messageFormat, messageArguments);
    }

    /// <summary>
    /// Asserts that the checked value is greater than the specified value.
    /// </summary>
    /// <param name="value">The value to check.</param>
    /// <param name="valueToCompareWith">The value to compare with.</param>
    /// <param name="messageFormat">A composite format <see cref="string"/>.</param>
    /// <param name="messageArguments">An array of message arguments to format.</param>
    [Conditional("DEBUG")]
    [StringFormatMethod("messageFormat")]
    public static void AssertIsGreater(
      this uint value,
      uint valueToCompareWith,
      [NotNull] string messageFormat,
      [CanBeNull] params object[] messageArguments)
    {
      Assert.IsTrue(value > valueToCompareWith, messageFormat, messageArguments);
    }

    /// <summary>
    /// Asserts that the checked value is less than the specified value.
    /// </summary>
    /// <param name="value">The value to check.</param>
    /// <param name="valueToCompareWith">The value to compare with.</param>
    /// <param name="messageFormat">A composite format <see cref="string"/>.</param>
    /// <param name="messageArguments">An array of message arguments to format.</param>
    [Conditional("DEBUG")]
    [StringFormatMethod("messageFormat")]
    public static void AssertIsLessThan(
      this int value,
      int valueToCompareWith,
      [NotNull] string messageFormat,
      [CanBeNull] params object[] messageArguments)
    {
      Assert.IsTrue(value < valueToCompareWith, messageFormat, messageArguments);
    }

    /// <summary>
    /// Asserts that the checked value is less than the specified value.
    /// </summary>
    /// <param name="value">The value to check.</param>
    /// <param name="valueToCompareWith">The value to compare with.</param>
    /// <param name="messageFormat">A composite format <see cref="string"/>.</param>
    /// <param name="messageArguments">An array of message arguments to format.</param>
    [Conditional("DEBUG")]
    [StringFormatMethod("messageFormat")]
    public static void AssertIsLessThan(
      this float value,
      float valueToCompareWith,
      [NotNull] string messageFormat,
      [CanBeNull] params object[] messageArguments)
    {
      Assert.IsTrue(value < valueToCompareWith, messageFormat, messageArguments);
    }

    /// <summary>
    /// Asserts that the checked value is less than the specified value.
    /// </summary>
    /// <param name="value">The value to check.</param>
    /// <param name="valueToCompareWith">The value to compare with.</param>
    /// <param name="messageFormat">A composite format <see cref="string"/>.</param>
    /// <param name="messageArguments">An array of message arguments to format.</param>
    [Conditional("DEBUG")]
    [StringFormatMethod("messageFormat")]
    public static void AssertIsLessThan(
      this double value,
      double valueToCompareWith,
      [NotNull] string messageFormat,
      [CanBeNull] params object[] messageArguments)
    {
      Assert.IsTrue(value < valueToCompareWith, messageFormat, messageArguments);
    }

    /// <summary>
    /// Asserts that the checked value is less than the specified value.
    /// </summary>
    /// <param name="value">The value to check.</param>
    /// <param name="valueToCompareWith">The value to compare with.</param>
    /// <param name="messageFormat">A composite format <see cref="string"/>.</param>
    /// <param name="messageArguments">An array of message arguments to format.</param>
    [Conditional("DEBUG")]
    [StringFormatMethod("messageFormat")]
    public static void AssertIsLessThan(
      this decimal value,
      decimal valueToCompareWith,
      [NotNull] string messageFormat,
      [CanBeNull] params object[] messageArguments)
    {
      Assert.IsTrue(value < valueToCompareWith, messageFormat, messageArguments);
    }

    /// <summary>
    /// Asserts that the checked value is less than the specified value.
    /// </summary>
    /// <param name="value">The value to check.</param>
    /// <param name="valueToCompareWith">The value to compare with.</param>
    /// <param name="messageFormat">A composite format <see cref="string"/>.</param>
    /// <param name="messageArguments">An array of message arguments to format.</param>
    [Conditional("DEBUG")]
    [StringFormatMethod("messageFormat")]
    public static void AssertIsLessThan(
      this uint value,
      uint valueToCompareWith,
      [NotNull] string messageFormat,
      [CanBeNull] params object[] messageArguments)
    {
      Assert.IsTrue(value < valueToCompareWith, messageFormat, messageArguments);
    }

    /// <summary>
    /// Asserts that the checked value is less than or equal to the specified value.
    /// </summary>
    /// <param name="value">The value to check.</param>
    /// <param name="valueToCompareWith">The value to compare with.</param>
    /// <param name="messageFormat">A composite format <see cref="string"/>.</param>
    /// <param name="messageArguments">An array of message arguments to format.</param>
    [Conditional("DEBUG")]
    [StringFormatMethod("messageFormat")]
    public static void AssertIsLessOrEqualTo(
      this int value,
      int valueToCompareWith,
      [NotNull] string messageFormat,
      [CanBeNull] params object[] messageArguments)
    {
      Assert.IsTrue(value <= valueToCompareWith, messageFormat, messageArguments);
    }

    /// <summary>
    /// Asserts that the checked value is less than or equal to the specified value.
    /// </summary>
    /// <param name="value">The value to check.</param>
    /// <param name="valueToCompareWith">The value to compare with.</param>
    /// <param name="messageFormat">A composite format <see cref="string"/>.</param>
    /// <param name="messageArguments">An array of message arguments to format.</param>
    [Conditional("DEBUG")]
    [StringFormatMethod("messageFormat")]
    public static void AssertIsLessOrEqualTo(
      this float value,
      float valueToCompareWith,
      [NotNull] string messageFormat,
      [CanBeNull] params object[] messageArguments)
    {
      Assert.IsTrue(value <= valueToCompareWith, messageFormat, messageArguments);
    }

    /// <summary>
    /// Asserts that the checked value is less than or equal to the specified value.
    /// </summary>
    /// <param name="value">The value to check.</param>
    /// <param name="valueToCompareWith">The value to compare with.</param>
    /// <param name="messageFormat">A composite format <see cref="string"/>.</param>
    /// <param name="messageArguments">An array of message arguments to format.</param>
    [Conditional("DEBUG")]
    [StringFormatMethod("messageFormat")]
    public static void AssertIsLessOrEqualTo(
      this double value,
      double valueToCompareWith,
      [NotNull] string messageFormat,
      [CanBeNull] params object[] messageArguments)
    {
      Assert.IsTrue(value <= valueToCompareWith, messageFormat, messageArguments);
    }

    /// <summary>
    /// Asserts that the checked value is less than or equal to the specified value.
    /// </summary>
    /// <param name="value">The value to check.</param>
    /// <param name="valueToCompareWith">The value to compare with.</param>
    /// <param name="messageFormat">A composite format <see cref="string"/>.</param>
    /// <param name="messageArguments">An array of message arguments to format.</param>
    [Conditional("DEBUG")]
    [StringFormatMethod("messageFormat")]
    public static void AssertIsLessOrEqualTo(
      this decimal value,
      decimal valueToCompareWith,
      [NotNull] string messageFormat,
      [CanBeNull] params object[] messageArguments)
    {
      Assert.IsTrue(value <= valueToCompareWith, messageFormat, messageArguments);
    }

    /// <summary>
    /// Asserts that the checked value is less than or equal to the specified value.
    /// </summary>
    /// <param name="value">The value to check.</param>
    /// <param name="valueToCompareWith">The value to compare with.</param>
    /// <param name="messageFormat">A composite format <see cref="string"/>.</param>
    /// <param name="messageArguments">An array of message arguments to format.</param>
    [Conditional("DEBUG")]
    [StringFormatMethod("messageFormat")]
    public static void AssertIsLessOrEqualTo(
      this uint value,
      uint valueToCompareWith,
      [NotNull] string messageFormat,
      [CanBeNull] params object[] messageArguments)
    {
      Assert.IsTrue(value <= valueToCompareWith, messageFormat, messageArguments);
    }

    /// <summary>
    /// Asserts that the checked value is greater than or equal to the specified value.
    /// </summary>
    /// <param name="value">The value to check.</param>
    /// <param name="valueToCompareWith">The value to compare with.</param>
    /// <param name="messageFormat">A composite format <see cref="string"/>.</param>
    /// <param name="messageArguments">An array of message arguments to format.</param>
    [Conditional("DEBUG")]
    [StringFormatMethod("messageFormat")]
    public static void AssertIsGreaterOrEqualTo(
      this int value,
      int valueToCompareWith,
      [NotNull] string messageFormat,
      [CanBeNull] params object[] messageArguments)
    {
      Assert.IsTrue(value >= valueToCompareWith, messageFormat, messageArguments);
    }

    /// <summary>
    /// Asserts that the checked value is greater than or equal to the specified value.
    /// </summary>
    /// <param name="value">The value to check.</param>
    /// <param name="valueToCompareWith">The value to compare with.</param>
    /// <param name="messageFormat">A composite format <see cref="string"/>.</param>
    /// <param name="messageArguments">An array of message arguments to format.</param>
    [Conditional("DEBUG")]
    [StringFormatMethod("messageFormat")]
    public static void AssertIsGreaterOrEqualTo(
      this float value,
      float valueToCompareWith,
      [NotNull] string messageFormat,
      [CanBeNull] params object[] messageArguments)
    {
      Assert.IsTrue(value >= valueToCompareWith, messageFormat, messageArguments);
    }

    /// <summary>
    /// Asserts that the checked value is greater than or equal to the specified value.
    /// </summary>
    /// <param name="value">The value to check.</param>
    /// <param name="valueToCompareWith">The value to compare with.</param>
    /// <param name="messageFormat">A composite format <see cref="string"/>.</param>
    /// <param name="messageArguments">An array of message arguments to format.</param>
    [Conditional("DEBUG")]
    [StringFormatMethod("messageFormat")]
    public static void AssertIsGreaterOrEqualTo(
      this double value,
      double valueToCompareWith,
      [NotNull] string messageFormat,
      [CanBeNull] params object[] messageArguments)
    {
      Assert.IsTrue(value >= valueToCompareWith, messageFormat, messageArguments);
    }

    /// <summary>
    /// Asserts that the checked value is greater than or equal to the specified value.
    /// </summary>
    /// <param name="value">The value to check.</param>
    /// <param name="valueToCompareWith">The value to compare with.</param>
    /// <param name="messageFormat">A composite format <see cref="string"/>.</param>
    /// <param name="messageArguments">An array of message arguments to format.</param>
    [Conditional("DEBUG")]
    [StringFormatMethod("messageFormat")]
    public static void AssertIsGreaterOrEqualTo(
      this decimal value,
      decimal valueToCompareWith,
      [NotNull] string messageFormat,
      [CanBeNull] params object[] messageArguments)
    {
      Assert.IsTrue(value >= valueToCompareWith, messageFormat, messageArguments);
    }

    /// <summary>
    /// Asserts that the checked value is greater than or equal to the specified value.
    /// </summary>
    /// <param name="value">The value to check.</param>
    /// <param name="valueToCompareWith">The value to compare with.</param>
    /// <param name="messageFormat">A composite format <see cref="string"/>.</param>
    /// <param name="messageArguments">An array of message arguments to format.</param>
    [Conditional("DEBUG")]
    [StringFormatMethod("messageFormat")]
    public static void AssertIsGreaterOrEqualTo(
      this uint value,
      uint valueToCompareWith,
      [NotNull] string messageFormat,
      [CanBeNull] params object[] messageArguments)
    {
      Assert.IsTrue(value >= valueToCompareWith, messageFormat, messageArguments);
    }


    /// <summary>
    /// Asserts that the checked value is equal to the specified value.
    /// </summary>
    /// <param name="value">The value to check.</param>
    /// <param name="valueToCompareWith">The value to compare with.</param>
    /// <param name="messageFormat">A composite format <see cref="string"/>.</param>
    /// <param name="messageArguments">An array of message arguments to format.</param>
    [Conditional("DEBUG")]
    [StringFormatMethod("messageFormat")]
    public static void AssertAreEqual(
      this int value,
      int valueToCompareWith,
      [NotNull] string messageFormat,
      [CanBeNull] params object[] messageArguments)
    {
      Assert.IsTrue(value == valueToCompareWith, messageFormat, messageArguments);
    }

    /// <summary>
    /// Asserts that the checked value is equal to the specified value.
    /// </summary>
    /// <param name="value">The value to check.</param>
    /// <param name="valueToCompareWith">The value to compare with.</param>
    /// <param name="messageFormat">A composite format <see cref="string"/>.</param>
    /// <param name="messageArguments">An array of message arguments to format.</param>
    [Conditional("DEBUG")]
    [StringFormatMethod("messageFormat")]
    public static void AssertAreEqual(
      this float value,
      float valueToCompareWith,
      [NotNull] string messageFormat,
      [CanBeNull] params object[] messageArguments)
    {
      Assert.IsTrue(value == valueToCompareWith, messageFormat, messageArguments);
    }

    /// <summary>
    /// Asserts that the checked value is equal to the specified value.
    /// </summary>
    /// <param name="value">The value to check.</param>
    /// <param name="valueToCompareWith">The value to compare with.</param>
    /// <param name="messageFormat">A composite format <see cref="string"/>.</param>
    /// <param name="messageArguments">An array of message arguments to format.</param>
    [Conditional("DEBUG")]
    [StringFormatMethod("messageFormat")]
    public static void AssertAreEqual(
      this double value,
      double valueToCompareWith,
      [NotNull] string messageFormat,
      [CanBeNull] params object[] messageArguments)
    {
      Assert.IsTrue(value == valueToCompareWith, messageFormat, messageArguments);
    }

    /// <summary>
    /// Asserts that the checked value is equal to the specified value.
    /// </summary>
    /// <param name="value">The value to check.</param>
    /// <param name="valueToCompareWith">The value to compare with.</param>
    /// <param name="messageFormat">A composite format <see cref="string"/>.</param>
    /// <param name="messageArguments">An array of message arguments to format.</param>
    [Conditional("DEBUG")]
    [StringFormatMethod("messageFormat")]
    public static void AssertAreEqual(
      this decimal value,
      decimal valueToCompareWith,
      [NotNull] string messageFormat,
      [CanBeNull] params object[] messageArguments)
    {
      Assert.IsTrue(value == valueToCompareWith, messageFormat, messageArguments);
    }

    /// <summary>
    /// Asserts that the checked value is equal to the specified value.
    /// </summary>
    /// <param name="value">The value to check.</param>
    /// <param name="valueToCompareWith">The value to compare with.</param>
    /// <param name="messageFormat">A composite format <see cref="string"/>.</param>
    /// <param name="messageArguments">An array of message arguments to format.</param>
    [Conditional("DEBUG")]
    [StringFormatMethod("messageFormat")]
    public static void AssertAreEqual(
      this uint value,
      uint valueToCompareWith,
      [NotNull] string messageFormat,
      [CanBeNull] params object[] messageArguments)
    {
      Assert.IsTrue(value == valueToCompareWith, messageFormat, messageArguments);
    }

    /// <summary>
    /// Asserts that the checked value is not equal to the specified value.
    /// </summary>
    /// <param name="value">The value to check.</param>
    /// <param name="valueToCompareWith">The value to compare with.</param>
    /// <param name="messageFormat">A composite format <see cref="string"/>.</param>
    /// <param name="messageArguments">An array of message arguments to format.</param>
    [Conditional("DEBUG")]
    [StringFormatMethod("messageFormat")]
    public static void AssertAreNotEqual(
      this int value,
      int valueToCompareWith,
      [NotNull] string messageFormat,
      [CanBeNull] params object[] messageArguments)
    {
      Assert.IsTrue(value != valueToCompareWith, messageFormat, messageArguments);
    }

    /// <summary>
    /// Asserts that the checked value is not equal to the specified value.
    /// </summary>
    /// <param name="value">The value to check.</param>
    /// <param name="valueToCompareWith">The value to compare with.</param>
    /// <param name="messageFormat">A composite format <see cref="string"/>.</param>
    /// <param name="messageArguments">An array of message arguments to format.</param>
    [Conditional("DEBUG")]
    [StringFormatMethod("messageFormat")]
    public static void AssertAreNotEqual(
      this float value,
      float valueToCompareWith,
      [NotNull] string messageFormat,
      [CanBeNull] params object[] messageArguments)
    {
      Assert.IsTrue(value != valueToCompareWith, messageFormat, messageArguments);
    }

    /// <summary>
    /// Asserts that the checked value is not equal to the specified value.
    /// </summary>
    /// <param name="value">The value to check.</param>
    /// <param name="valueToCompareWith">The value to compare with.</param>
    /// <param name="messageFormat">A composite format <see cref="string"/>.</param>
    /// <param name="messageArguments">An array of message arguments to format.</param>
    [Conditional("DEBUG")]
    [StringFormatMethod("messageFormat")]
    public static void AssertAreNotEqual(
      this double value,
      double valueToCompareWith,
      [NotNull] string messageFormat,
      [CanBeNull] params object[] messageArguments)
    {
      Assert.IsTrue(value != valueToCompareWith, messageFormat, messageArguments);
    }

    /// <summary>
    /// Asserts that the checked value is not equal to the specified value.
    /// </summary>
    /// <param name="value">The value to check.</param>
    /// <param name="valueToCompareWith">The value to compare with.</param>
    /// <param name="messageFormat">A composite format <see cref="string"/>.</param>
    /// <param name="messageArguments">An array of message arguments to format.</param>
    [Conditional("DEBUG")]
    [StringFormatMethod("messageFormat")]
    public static void AssertAreNotEqual(
      this decimal value,
      decimal valueToCompareWith,
      [NotNull] string messageFormat,
      [CanBeNull] params object[] messageArguments)
    {
      Assert.IsTrue(value != valueToCompareWith, messageFormat, messageArguments);
    }

    /// <summary>
    /// Asserts that the checked value is not equal to the specified value.
    /// </summary>
    /// <param name="value">The value to check.</param>
    /// <param name="valueToCompareWith">The value to compare with.</param>
    /// <param name="messageFormat">A composite format <see cref="string"/>.</param>
    /// <param name="messageArguments">An array of message arguments to format.</param>
    [Conditional("DEBUG")]
    [StringFormatMethod("messageFormat")]
    public static void AssertAreNotEqual(
      this uint value,
      uint valueToCompareWith,
      [NotNull] string messageFormat,
      [CanBeNull] params object[] messageArguments)
    {
      Assert.IsTrue(value != valueToCompareWith, messageFormat, messageArguments);
    }

    /// <summary>
    /// Asserts that the checked value is NaN.
    /// </summary>
    /// <param name="value">The value to check.</param>
    /// <param name="messageFormat">A composite format <see cref="string"/>.</param>
    /// <param name="messageArguments">An array of message arguments to format.</param>
    [Conditional("DEBUG")]
    [StringFormatMethod("messageFormat")]
    public static void AssertIsNaN(
      this float value,
      [NotNull] string messageFormat,
      [CanBeNull] params object[] messageArguments)
    {
      Assert.IsTrue(float.IsNaN(value), messageFormat, messageArguments);
    }

    /// <summary>
    /// Asserts that the checked value is NaN.
    /// </summary>
    /// <param name="value">The value to check.</param>
    /// <param name="messageFormat">A composite format <see cref="string"/>.</param>
    /// <param name="messageArguments">An array of message arguments to format.</param>
    [Conditional("DEBUG")]
    [StringFormatMethod("messageFormat")]
    public static void AssertIsNaN(
      this double value,
      [NotNull] string messageFormat,
      [CanBeNull] params object[] messageArguments)
    {
      Assert.IsTrue(double.IsNaN(value), messageFormat, messageArguments);
    }

    /// <summary>
    /// Asserts that the checked value is not NaN.
    /// </summary>
    /// <param name="value">The value to check.</param>
    /// <param name="messageFormat">A composite format <see cref="string"/>.</param>
    /// <param name="messageArguments">An array of message arguments to format.</param>
    [Conditional("DEBUG")]
    [StringFormatMethod("messageFormat")]
    public static void AssertIsNotNaN(
      this float value,
      [NotNull] string messageFormat,
      [CanBeNull] params object[] messageArguments)
    {
      Assert.IsTrue(!float.IsNaN(value), messageFormat, messageArguments);
    }

    /// <summary>
    /// Asserts that the checked value is not NaN.
    /// </summary>
    /// <param name="value">The value to check.</param>
    /// <param name="messageFormat">A composite format <see cref="string"/>.</param>
    /// <param name="messageArguments">An array of message arguments to format.</param>
    [Conditional("DEBUG")]
    [StringFormatMethod("messageFormat")]
    public static void AssertIsNotNaN(
      this double value,
      [NotNull] string messageFormat,
      [CanBeNull] params object[] messageArguments)
    {
      Assert.IsTrue(!double.IsNaN(value), messageFormat, messageArguments);
    }
  }
}